package com.zhentao.controller;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.zhentao.pojo.WxCategory;
import com.zhentao.pojo.WxProduct;
import com.zhentao.service.WxCategoryService;
import com.zhentao.service.WxProductService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.math.BigDecimal;
import java.util.List;

@RequestMapping("index")
@RestController
public class IndexController {
    
    @Autowired
    private WxProductService wxProductService;
    
    @Autowired
    private WxCategoryService wxCategoryService;
    
    /**
     * 查询所有商品
     * @return 所有商品列表
     */
    @GetMapping("/products")
    public List<WxProduct> getAllProducts() {
        return wxProductService.list();
    }
    
    /**
     * 根据分类查询商品
     * @param categoryId 分类ID
     * @return 该分类下的商品列表
     */
    @GetMapping("/products/category/{categoryId}")
    public List<WxProduct> getProductsByCategory(@PathVariable Integer categoryId) {
        QueryWrapper<WxProduct> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("category_id", categoryId);
        return wxProductService.list(queryWrapper);
    }
    
    /**
     * 根据商品ID查询商品详情
     * @param productId 商品ID
     * @return 商品详情
     */
    @GetMapping("/products/{productId}")
    public WxProduct getProductDetail(@PathVariable Integer productId) {
        return wxProductService.getById(productId);
    }
    
    /**
     * 查询所有分类
     * @return 所有分类列表
     */
    @GetMapping("/categories")
    public List<WxCategory> getAllCategories() {
        return wxCategoryService.list();
    }
    
    /**
     * 根据商品名称搜索商品
     * @param productName 商品名称关键字
     * @return 匹配的商品列表
     */
    @GetMapping("/products/search")
    public List<WxProduct> searchProductsByName(@RequestParam String productName) {
        QueryWrapper<WxProduct> queryWrapper = new QueryWrapper<>();
        queryWrapper.like("product_name", productName);
        return wxProductService.list(queryWrapper);
    }
    
    /**
     * 查询一级分类（父分类）
     * @return 一级分类列表
     */
    @GetMapping("/categories/parent")
    public List<WxCategory> getParentCategories() {
        QueryWrapper<WxCategory> queryWrapper = new QueryWrapper<>();
        queryWrapper.isNull("parent_category_id").or().eq("parent_category_id", 0);
        return wxCategoryService.list(queryWrapper);
    }
    
    /**
     * 根据父分类ID查询子分类（二级分类）
     * @param parentCategoryId 父分类ID
     * @return 子分类列表
     */
    @GetMapping("/categories/children/{parentCategoryId}")
    public List<WxCategory> getChildCategories(@PathVariable Integer parentCategoryId) {
        QueryWrapper<WxCategory> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("parent_category_id", parentCategoryId);
        return wxCategoryService.list(queryWrapper);
    }
    
    /**
     * 根据价格区间查询商品
     * @param minPrice 最低价格（元为单位）
     * @param maxPrice 最高价格（元为单位，可选）
     * @return 价格区间内的商品列表
     */
    @GetMapping("/products/price-range")
    public List<WxProduct> getProductsByPriceRange(
            @RequestParam BigDecimal minPrice,
            @RequestParam(required = false) BigDecimal maxPrice) {
        QueryWrapper<WxProduct> queryWrapper = new QueryWrapper<>();
        
        // 最低价格条件
        if (minPrice != null && minPrice.compareTo(BigDecimal.ZERO) >= 0) {
            queryWrapper.ge("price", minPrice);
        }
        
        // 最高价格条件（如果提供）
        if (maxPrice != null && maxPrice.compareTo(BigDecimal.ZERO) > 0) {
            queryWrapper.le("price", maxPrice);
        }
        
        // 确保价格区间的合理性
        if (minPrice != null && maxPrice != null && maxPrice.compareTo(minPrice) < 0) {
            throw new IllegalArgumentException("最高价格不能小于最低价格");
        }
        
        return wxProductService.list(queryWrapper);
    }
    
    /**
     * 根据价格排序查询商品
     * @param sortType 排序类型：asc-价格从低到高，desc-价格从高到低
     * @param categoryId 分类ID（可选）
     * @return 按价格排序的商品列表
     */
    @GetMapping("/products/sort-by-price")
    public List<WxProduct> getProductsSortedByPrice(
            @RequestParam(defaultValue = "asc") String sortType,
            @RequestParam(required = false) Integer categoryId) {
        QueryWrapper<WxProduct> queryWrapper = new QueryWrapper<>();
        
        // 如果指定分类，添加分类条件
        if (categoryId != null && categoryId > 0) {
            queryWrapper.eq("category_id", categoryId);
        }
        
        // 价格排序
        if ("desc".equalsIgnoreCase(sortType)) {
            queryWrapper.orderByDesc("price");
        } else {
            queryWrapper.orderByAsc("price");
        }
        
        return wxProductService.list(queryWrapper);
    }
    
    /**
     * 根据销量排序查询商品
     * @param sortType 排序类型：desc-销量从高到低（默认），asc-销量从低到高
     * @param categoryId 分类ID（可选）
     * @return 按销量排序的商品列表
     */
    @GetMapping("/products/sort-by-sales")
    public List<WxProduct> getProductsSortedBySales(
            @RequestParam(defaultValue = "desc") String sortType,
            @RequestParam(required = false) Integer categoryId) {
        QueryWrapper<WxProduct> queryWrapper = new QueryWrapper<>();
        
        // 如果指定分类，添加分类条件
        if (categoryId != null && categoryId > 0) {
            queryWrapper.eq("category_id", categoryId);
        }
        
        // 销量排序
        if ("asc".equalsIgnoreCase(sortType)) {
            queryWrapper.orderByAsc("sales_volume");
        } else {
            queryWrapper.orderByDesc("sales_volume");
        }
        
        return wxProductService.list(queryWrapper);
    }
    
    /**
     * 综合查询商品（支持价格区间、排序、分类等多条件）
     * @param categoryId 分类ID（可选）
     * @param minPrice 最低价格（元为单位，可选）
     * @param maxPrice 最高价格（元为单位，可选）
     * @param sortBy 排序字段：price-按价格排序，sales-按销量排序，默认不排序
     * @param sortType 排序类型：asc-升序，desc-降序
     * @param keyword 商品名称关键字（可选）
     * @return 符合条件的商品列表
     */
    @GetMapping("/products/query")
    public List<WxProduct> queryProducts(
            @RequestParam(required = false) Integer categoryId,
            @RequestParam(required = false) BigDecimal minPrice,
            @RequestParam(required = false) BigDecimal maxPrice,
            @RequestParam(required = false) String sortBy,
            @RequestParam(defaultValue = "asc") String sortType,
            @RequestParam(required = false) String keyword) {
        QueryWrapper<WxProduct> queryWrapper = new QueryWrapper<>();
        
        // 分类条件
        if (categoryId != null && categoryId > 0) {
            queryWrapper.eq("category_id", categoryId);
        }
        
        // 价格区间条件
        if (minPrice != null && minPrice.compareTo(BigDecimal.ZERO) >= 0) {
            queryWrapper.ge("price", minPrice);
        }
        if (maxPrice != null && maxPrice.compareTo(BigDecimal.ZERO) > 0) {
            queryWrapper.le("price", maxPrice);
        }
        
        // 关键字搜索
        if (keyword != null && !keyword.trim().isEmpty()) {
            queryWrapper.like("product_name", keyword.trim());
        }
        
        // 排序条件
        if ("price".equalsIgnoreCase(sortBy)) {
            if ("desc".equalsIgnoreCase(sortType)) {
                queryWrapper.orderByDesc("price");
            } else {
                queryWrapper.orderByAsc("price");
            }
        } else if ("sales".equalsIgnoreCase(sortBy)) {
            if ("desc".equalsIgnoreCase(sortType)) {
                queryWrapper.orderByDesc("sales_volume");
            } else {
                queryWrapper.orderByAsc("sales_volume");
            }
        }
        
        // 验证价格区间的合理性
        if (minPrice != null && maxPrice != null && maxPrice.compareTo(minPrice) < 0) {
            throw new IllegalArgumentException("最高价格不能小于最低价格");
        }
        
        return wxProductService.list(queryWrapper);
    }
}
